// 'use strict'; // TypeScript 默认在严格模式下编译  

import $config from '../config/config.js'; // 注意：这个导入在方法中没有使用，如果不需要可以移除  

class Util {
	// 由于方法不依赖于实例状态，因此将它们转换为静态方法  

	/**  
	 * @description 日期格式化  
	 * @param date 日期对象或可解析为日期的字符串  
	 * @param fmt 格式化字符串  
	 * @returns 格式化后的日期字符串  
	 */
	static format(date : Date | string, fmt : string = 'yyyy-MM-dd hh:mm:ss') : string {
		if (!date) {
			return '';
		}
		if (typeof date === 'string') {
			date = new Date(date.replace(/\.|\-/g, '/'));
			if (isNaN(date.getTime())) {
				throw new Error('Invalid date string');
			}
		}

		const o = {
			'M+': (date.getMonth() + 1).toString(), // 月份  
			'd+': date.getDate().toString(), // 日  
			'h+': date.getHours().toString(), // 小时  
			'm+': date.getMinutes().toString(), // 分  
			's+': date.getSeconds().toString(), // 秒  
			'q+': Math.floor((date.getMonth() + 3) / 3).toString(), // 季度  
			'S': date.getMilliseconds().toString() // 毫秒  
		};

		if (/(y+)/.test(fmt)) {
			fmt = fmt.replace(RegExp.$1, (date.getFullYear() + '').substr(4 - RegExp.$1.length));
		}

		for (const k in o) {
			if (new RegExp(`(${k})`).test(fmt)) {
				const str = o[k];
				fmt = fmt.replace(RegExp.$1, (RegExp.$1.length === 1) ? str : ('00' + str).substr(str.length));
			}
		}

		return fmt;
	}

	/**  
	 * 日期格式化，返回格式为 yyyy-mm-dd  
	 * @param date 日期对象或可解析为日期的字符串  
	 * @returns 格式化后的日期字符串  
	 */
	static formatDate(date : Date | string) : string {
		let d : Date;
		if (typeof date === 'string') {
			d = new Date(date.replace(/\.|\-/g, '/'));
			if (isNaN(d.getTime())) {
				throw new Error('Invalid date string');
			}
		} else {
			d = date;
		}

		const y = d.getFullYear();
		let m = (d.getMonth() + 1).toString();
		m = m.length < 2 ? '0' + m : m;
		let day = d.getDate().toString();
		day = day.length < 2 ? '0' + day : day;

		return `${y}-${m}-${day}`;
	}
	static formatNumber(n : any) : string {
		n = n.toString();
		return n[1] ? n : '0' + n;
	}

	static formatRandom() : string {
		let code = '';
		for (let i = 0; i < 6; i++) {
			code += (Math.floor(Math.random() * 10)).toString();
		}
		return code;
	}
	/**  
	 * 显示消息提示（Toast）  
	 * @param title 提示的标题，如果非字符串类型，则会被转换为 JSON 字符串  
	 * @param duration 提示显示的毫秒数，默认为 2500ms  
	 * @param mask 是否显示透明蒙层，防止触摸穿透，默认为 false  
	 * @param icon 图标，有效值：'success'、'loading'、'none'，默认为 'none'  
	 */
	static msg(title : string | object, duration : number = 2500, mask : boolean = false, icon : 'success' | 'loading' | 'none' = 'none') : void {
		if (!title) return;
		if (typeof title !== 'string') {
			title = JSON.stringify(title);
		}

		uni.showToast({
			title,
			duration,
			mask,
			icon
		});
	}

	/**  
	 * 显示模态对话框（Alert）  
	 * @param content 对话框的内容，如果非字符串类型，则会被转换为 JSON 字符串  
	 * @param callback 点击确定或取消按钮时的回调函数，回调函数接收一个布尔值参数表示是否点击确定  
	 * @param showCancel 是否显示取消按钮，默认为 true  
	 */
	static alert(content : string | object, callback ?: (confirm : boolean) => void, showCancel : boolean = true) : void {
		if (typeof content !== 'string') {
			content = JSON.stringify(content);
		}

		uni.showModal({
			title: '提示',
			content: content,
			showCancel,
			success: (res) => {
				if (res.confirm) {
					if (typeof callback === 'function') {
						callback(true);
					}
				} else if (res.cancel && showCancel) {
					if (typeof callback === 'function') {
						callback(false);
					}
				}
			}
		});
	}
	/**  
	* 跳转登录页  
	* @param redirect 是否重定向到登录页  
	*/
	static tologin(redirect : boolean) : void {
		if (redirect) {
			uni.redirectTo({
				url: $config.route.login
			});
		} else {
			uni.navigateTo({
				url: $config.route.login
			});
		}
	}

	/**  
	 * 跳转首页  
	 */
	static tohome() : void {
		console.log($config)
		uni.switchTab({
			url: $config.route.home
		});
	}

	/**  
	 * 跳转启动页  
	 */
	static tolaunch() : void {
		uni.redirectTo({
			url: $config.route.launch
		});
	}
	/**
	 * @description 超时
	 */
	static timerout(callback: Function, timer: number = 1000) {
	  let _timer = setTimeout(() => {
	    if (typeof callback === 'function') {
	      callback();
	    }
	    clearTimeout(_timer);
	  }, timer);
	}
	
	
	//*************** 图片压缩 ***********
	// 判断图片大小是否满足需求
	static imageSizeIsLessLimitSize(imagePath, limitSize, lessCallBack, moreCallBack) {
		uni.getFileInfo({
			filePath: imagePath,
			success(res) {
				console.log("压缩前图片大小:", res.size / 1024, 'kb');
				if (res.size > 1024 * limitSize) {
					moreCallBack();
				} else {
					lessCallBack();
				}
			}
		})
	};
	/**
	 * 获取画布图片 
	 */
	// 利用cavas进行压缩  每次压缩都需要ctx.draw()  wx.canvasToTempFilePath()连用
	static getCanvasImage(canvasId, imagePath, imageW, imageH, getImgsuccess) {
		const ctx = uni.createCanvasContext(canvasId);
		ctx.drawImage(imagePath, 0, 0, imageW, imageH);
		ctx.draw(false, function () { // 一定要加定时器，因为ctx.draw()应用到canvas是有个时间的
			setTimeout(function () {
				uni.canvasToTempFilePath({
					canvasId: canvasId,
					x: 0,
					y: 0,
					width: imageW,
					height: imageH,
					quality: 1,
					success: function (res) {
						getImgsuccess(res.tempFilePath);
					},
				});
			}, 200);
		})
	};
	
	// 主调用方法
	
	/**
	 * 获取小于限制大小的Image, limitSize默认为100KB，递归调用。
	 */
	static getLessLimitSizeImage(canvasId, imagePath, limitSize = 100, drawWidth, callBack) {
		let self=this;
		this.imageSizeIsLessLimitSize(imagePath, limitSize,
			(lessRes) => {
				callBack(imagePath);
			},
			(moreRes) => {
				uni.getImageInfo({
					src: imagePath,
					success: function (imageInfo) {
						var maxSide = Math.max(imageInfo.width, imageInfo.height);
						//画板的宽高默认是windowWidth
						var windowW = drawWidth;
						var scale = 1;
						if (maxSide > windowW) {
							scale = windowW / maxSide;
						}
						var imageW = Math.trunc(imageInfo.width * scale);
						var imageH = Math.trunc(imageInfo.height * scale);
						console.log('调用压缩', imageW, imageH);
						self.getCanvasImage(canvasId, imagePath, imageW, imageH,
							(pressImgPath) => {
								self.getLessLimitSizeImage(canvasId, pressImgPath, limitSize, drawWidth * 0.95, callBack);
							}
						);
					}
				})
			}
		)
	};
	// 图片转basee64    io操作 使用异步方式
	static getBase64(img) {
		return new Promise(function (resolve, reject) {
			const FSM = uni.getFileSystemManager();
			FSM.readFile({
				filePath: img,
				encoding: 'base64',
				success(data) {
					resolve(data)
				}
			})
		})
	}
}

export default Util; // 导出类本身，而不是类的实例